package com.tianzj.util;

import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

import org.apache.commons.lang3.time.DateFormatUtils;


public class DateUtils {

	private DateUtils() {
	}
	
	public static String format(Date date) {
		try {
			return DateFormatUtils.format(date, "yyyy-MM-dd");
		} catch (Exception e) {
			return null;
		}
	}

	public static String format(Date date, String pattern) {
		try {
			return DateFormatUtils.format(date, pattern);
		} catch (Exception e) {
			return null;
		}
	}
	
	public static String format(Calendar date, String pattern) {
		try {
			return DateFormatUtils.format(date, pattern);
		} catch (Exception e) {
			return null;
		}
	}

	public static Date parse(String date, String pattern) {
		SimpleDateFormat format = new SimpleDateFormat(pattern);
		ParsePosition pos = new ParsePosition(0);

		return format.parse(date, pos);
	}

	public static Date parse(String date) {
		SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
		ParsePosition pos = new ParsePosition(0);
		return format.parse(date, pos);
	}
	
	/**
	 * 返回指定日期加上若干年/月/日
	 * 
	 * @param date 要累加的日期
	 * @param year 加多少年
	 * @param month 加多少个月
	 * @param day 加多少天
	 * @param format 返回的日期格式
	 * 
	 * @return date String
	 */
	public static String getAddDate(String date, int year, int month, int day, String format) {
		Calendar cal = Calendar.getInstance();
		SimpleDateFormat sFmt = new SimpleDateFormat(format);
		cal.setTime(parse(date, format));

		if (day != 0) {
			cal.add(Calendar.DATE, day);
		}
		if (month != 0) {
			cal.add(Calendar.MONTH, month);
		}
		if (year != 0) {
			cal.add(Calendar.YEAR, year);
		}
		
		return sFmt.format(cal.getTime());
	}
	
	
	/**
	 * 两个字符日期相减，得到相差天数
	 * 	如果开始时间（start）比结束时间（end）大，则返回负数
	 * @param start
	 * @param end
	 * @return 天数
	 */
	public static long getInterval(String start, String end) {
		try {
			Date startTime = parse(start);
			Date endTime = parse(end);
			
			return getInterval(startTime, endTime);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 两个日期相减，得到相差天数
	 * 	如果开始时间（startTime）比结束时间（endTime）大，则返回负数
	 * @param startTime
	 * @param endTime
	 * @return 天数
	 */
	public static long getInterval(Date startTime, Date endTime) {
		try {
			return (endTime.getTime() - startTime.getTime()) / (24 * 60 * 60 * 1000);
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 获得一段时间内的所有日期
	 * @param dBegin
	 * @param dEnd
	 * @return
	 */
	public static List<Date> findDates(Date dBegin, Date dEnd) {
		List<Date> lDate = new ArrayList<Date>();
		lDate.add(dBegin);
		
		Calendar calendar = Calendar.getInstance();
		// 使用给定的 Date 设置此 Calendar 的时间
		calendar.setTime(dBegin);
		
		// 测试此日期是否在指定日期之后
		while (dEnd.after(calendar.getTime())) {
			// 根据日历的规则，为给定的日历字段添加或减去指定的时间量
			calendar.add(Calendar.DAY_OF_MONTH, 1);
			lDate.add(calendar.getTime());
		}
		return lDate;
	}

	/**
	 * 指定时间延迟若干个等时
	 * 
	 * @param now 指定的时间
	 * @param pattern 格式化样式
	 * @param delay 延迟等时个数
	 * @param time 一个等时
	 * @return
	 */
	public static String getDelay(String now, String pattern, Integer delay, Integer time) {
		try {
			Date date = parse(now, pattern);
			long delayTime = (date.getTime() / 1000) + delay * time;
			date.setTime(delayTime * 1000);

			return DateFormatUtils.format(date, pattern);
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * 获取指定时间的上个月第一天
	 * 
	 * @param now
	 * @param pattern
	 * @return
	 */
	public static String getPreMonthFirst(String now, String pattern) {
		Calendar c = Calendar.getInstance();
		c.setTime(parse(now, pattern));
		c.set(Calendar.DATE, 1);
		c.add(Calendar.MONTH, -1);

		return format(c, "yyyy-MM-dd");
	}

	/**
	 * 获取指定时间延迟若干天
	 * 
	 * @param now
	 * @param delay
	 * @param pattern
	 * @return
	 */
	public static String getDelayDay(String now, Integer delay, String pattern) {
		return getDelay(now, pattern, delay, 24 * 60 * 60);
	}

	/**
	 * 获取指定时间延迟若干小时
	 * 
	 * @param now
	 * @param delay
	 * @param pattern
	 * @return
	 */
	public static String getDelayHour(String now, Integer delay, String pattern) {
		return getDelay(now, pattern, delay, 60 * 60);
	}

	/**
	 * 获取指定时间延迟若干分钟
	 * 
	 * @param now
	 * @param delay
	 * @param pattern
	 * @return
	 */
	public static String getDelayMinute(String now, Integer delay, String pattern) {
		return getDelay(now, pattern, delay, 60);
	}

	public static String getWeek(Date date) {
		Calendar c = Calendar.getInstance();
		c.setTime(date);

		return format(c, "EEEE");
	}

	/**
	 * 获取指定时间加上若干天
	 * 
	 * @param count
	 * @param day
	 * @return
	 */
	public static String getAddDay(String day, int count) {
		return getAddDay(parse(day), count);
	}
	
	/**
	 * 获取指定时间加上若干天
	 * @param day
	 * @param count
	 * @return
	 */
	public static String getAddDay(Date day, int count) {
		Long time = (day.getTime() / 1000) + 60 * 60 * 24 * count;
		day.setTime(time * 1000);
		
		return format(day, "yyyy-MM-dd HH:mm:ss");
	}

	/**
	 * 获取两个（不带日期的）时间戳相差的分钟数
	 * @param startTime
	 * @param endTime
	 * @return
	 */
	public static long hasMinute(String startTime, String endTime) {
		Date start = parse("1970-01-20 "+ startTime, "yyyy-MM-dd HH:mm:ss");
		Date end = parse("1970-01-20 "+ endTime, "yyyy-MM-dd HH:mm:ss");
		
		return hasMinute(start, end);
	}
	
	/**
	 * 获取两个时间相差的分钟数
	 * 
	 * @param start 开始时间
	 * @param end 结束时间
	 * @return 分钟数
	 */
	public static long hasMinute(Date start, Date end) {
		try {
			long result = end.getTime() - start.getTime();
			result = result / (1000 * 60);// 分钟数
			return result;
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return 0;
	}

	/**
	 * 根据年份、周返回指定月份的日期段
	 * 
	 * @param year 年
	 * @param week 周
	 * @param month 月
	 * @return
	 */
	public static String getDateByWeek(int year, int week, int month) {
		String ret = "";
		Calendar c = Calendar.getInstance();
		c.set(year, 0, 1);
		int day_week = c.get(Calendar.DAY_OF_WEEK);
		// c.add(Calendar.DATE, -(day_week-1));
		c.add(Calendar.DATE, 7 * week - (day_week - 1));

		if ((month - c.get(Calendar.MONTH)) != 1) {
			ret += "1-";
			c.add(Calendar.DATE, 6);
			ret += c.get(Calendar.DAY_OF_MONTH);
		} else {
			int sun_week = c.get(Calendar.DAY_OF_MONTH);
			ret += sun_week + "-";
			c.add(Calendar.DATE, 6);
			int sat_week = c.get(Calendar.DAY_OF_MONTH);
			if (sat_week > sun_week) {
				ret += sat_week;
			} else {
				ret += (6 - sat_week + sun_week);
			}
		}

		return ret;
	}
	
	/**
	 * 根据日期获取所在月每周开始结束日期
	 * @param date yyyy-MM-dd或yyyy-MM
	 * @return
	 */
	public static List<String> getWeeks(String date) {
		List<String> list = new ArrayList<String>();
		try {
			// String date = "2013-09";
			Date date1 = parse(date, "yyyy-MM");
			Calendar calendar = new GregorianCalendar();
			calendar.setTime(date1);
			int days = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
			//System.out.println("days:" + days);
			int count = 0;
			String start,end;
			for (int i = 1; i <= days; i++) {
				Date date2 = parse(date + "-" + i);
				calendar.clear();
				calendar.setTime(date2);
				int k = new Integer(calendar.get(Calendar.DAY_OF_WEEK));
				if (k == 1) {// 若当天是周日
					count++;
					//System.out.println("-----------------------------------");
					//System.out.println("第" + count + "周");
					if (i - 6 <= 1) {
						//System.out.println("本周开始日期:" + date + "-" + 1);
						start = date + "-" + 1;
					} else {
						//System.out.println("本周开始日期:" + date + "-" + (i - 6));
						start = date + "-" + (i - 6);
					}
					//System.out.println("本周结束日期:" + date + "-" + i);
					end = date + "-" + i;
					//System.out.println("-----------------------------------");
					list.add(start +"|"+ end);
				}
				if (k != 1 && i == days) {// 若是本月最后一天，且不是周日
					count++;
					//System.out.println("-----------------------------------");
					//System.out.println("第" + count + "周");
					//System.out.println("本周开始日期:" + date + "-" + (i - k + 2));
					start = date + "-" + (i - k + 2);
					//System.out.println("本周结束日期:" + date + "-" + i);
					end = date + "-" + i;
					//System.out.println("-----------------------------------");
					list.add(start +"|"+ end);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return list;
	}

	/**
	 * 月份相减
	 * 
	 * @param start 开始日期（yyyy-MM）
	 * @param end 结束日期 （yyyy-MM）
	 * @return 两个日期相差的月数
	 */
	public static int getMonthInterval(String start, String end) {
		try {
			return getMonthInterval(parse(start), parse(end));
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return 0;
	}
	
	/**
	 * 月份相减
	 * @param start
	 * @param end
	 * @return
	 */
	public static int getMonthInterval(Date start, Date end) {
		try {
			Calendar startCal = Calendar.getInstance();
			startCal.setTime(start);
			Calendar endCal = Calendar.getInstance();
			endCal.setTime(end);
			
			// 年份之差 + 月份之差
			return (endCal.get(1) - startCal.get(1)) * 12 + (endCal.get(2) - startCal.get(2));
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return 0;
	}
	
	/**
	 * 获得当前月和下个月的天数后相减
	 * @param start
	 * @param end
	 * @return
	 */
	public static int getDayInterval(Date start, Date end) {
		try {
			Calendar startCal = Calendar.getInstance();
			startCal.setTime(start);
			int i = startCal.get(Calendar.MONTH);
			Calendar endCal = Calendar.getInstance();
			endCal.setTime(end);
			int j = endCal.get(Calendar.MONTH);
			if(i == j){
				return (endCal.get(Calendar.DAY_OF_MONTH) - startCal.get(Calendar.DAY_OF_MONTH));
			} else if (j - i == 1 || j - i == -11){
				int today = startCal.get(Calendar.DAY_OF_MONTH);
				// 设置日期为本月最大日期
				startCal.set(Calendar.DATE, startCal.getActualMaximum(Calendar.DATE));
				int endDay = startCal.get(Calendar.DAY_OF_MONTH);
				return (endDay - today + endCal.get(Calendar.DAY_OF_MONTH));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return -1;
	}

	/**
	 * 获取指定日期加上若干月后的日期
	 * 
	 * @param date 起始日期 （yyyy-MM）
	 * @param n 月数
	 * @return 日期 （yyyy-MM）
	 */
	public static String getAddCountMonth(String date, int n) {
		try {
			Calendar c = Calendar.getInstance();
			c.setTime(parse(date));
			c.add(Calendar.MONTH, n);
			
			return format(c.getTime(), "yyyy-MM-dd HH:mm:ss");
		} catch (Exception e) {
			e.printStackTrace();
		}
		
		return null;
	}

	/**
	 * 得到当前日期是周几
	 * 	返回的是数字 0是周日--6是周六
	 * 
	 * @param date
	 * @return
	 */
	public static int getDateOfWeek(String date) {
		Calendar cal = Calendar.getInstance();
		cal.setTime(parse(date));
		
		// 获得今天是一周的第几天，星期日是第一天，星期一是第二天......
		return cal.get(Calendar.DAY_OF_WEEK) - 1; // 按中国礼拜一作为第一天所以这里减1
	}

	/**
	 * 获取指定日期所在周的第一天
	 * @param date 日期 （yyyy-MM-dd）
	 * @return 日期 （yyyy-MM-dd）
	 */
	public static String getFirstDayOfWeek(String date){
		Calendar cal = Calendar.getInstance();
		cal.setTime(parse(date));
		int day_of_week = cal.get(Calendar.DAY_OF_WEEK) - 1;
		if (day_of_week == 0)
			day_of_week = 7;
		cal.add(Calendar.DATE, -day_of_week + 1);
		
		return format(cal.getTime());
	}
	
	/**
	 * 获取指定日期所在周的最后一天
	 * @param date 日期 （yyyy-MM-dd）
	 * @return 日期 （yyyy-MM-dd）
	 */
	public static String getLastDayOfWeek(String date){
		Calendar cal = Calendar.getInstance();
		cal.setTime(parse(date));
		int day_of_week = cal.get(Calendar.DAY_OF_WEEK) - 1;
		if (day_of_week == 0)
			day_of_week = 7;
		cal.add(Calendar.DATE, -day_of_week + 7);
		
		return format(cal.getTime());
	}
	
	/**
	 * 获取指定日期所在月的第一天
	 * 
	 * @param date 日期 （yyyy-MM-dd）
	 * @return 日期 （yyyy-MM-dd）
	 */
	public static String getFirstDayOfMonth(String date) {
		String[] ss = date.split("-");
		
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.YEAR, Integer.valueOf(ss[0]));
		cal.set(Calendar.MONTH, Integer.valueOf(ss[1]) - 1);
		int minDay = cal.getActualMinimum(Calendar.DATE);
		
		if (minDay < 10) {
			return ss[0] +"-"+ ss[1] +"-0"+ minDay;
		} else {
			return ss[0] +"-"+ ss[1] +"-"+ minDay;
		}
	}
	
	/**
	 * 获取指定日期所在月的最后一天
	 * 
	 * @param date 日期 （yyyy-MM-dd）
	 * @return 日期 （yyyy-MM-dd）
	 */
	public static String getLastDayOfMonth(String date) {
		Calendar cal = Calendar.getInstance();  
	    cal.setTime(parse(date));  
	    int last = cal.getActualMaximum(Calendar.DAY_OF_MONTH);  
	    cal.set(Calendar.DAY_OF_MONTH, last);
		return format(cal.getTime());
		
		/*String[] ss = date.split("-");
		
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.YEAR, Integer.valueOf(ss[0]));
		cal.set(Calendar.MONTH, Integer.valueOf(ss[1]) - 1);
		int maxDay = cal.getActualMaximum(Calendar.DATE);
		
		return ss[0] +"-"+ ss[1] +"-"+ maxDay;*/
	}
	
	/**
	 * 获取指定日期所在月的前后N月的第一天
	 * 
	 * @param date 日期 （yyyy-MM-dd）
	 * @return 日期 （yyyy-MM-dd）
	 */
	public static String getFirstDayOfMonth(String date,Integer num) {
		String[] ss = date.split("-");
		
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.YEAR, Integer.valueOf(ss[0]));
		cal.set(Calendar.MONTH, Integer.valueOf(ss[1]) - (1-num));
		int minDay = cal.getActualMinimum(Calendar.DATE);
		
		if (minDay < 10) {
			return ss[0] +"-"+ (Integer.valueOf(ss[1])+num) +"-0"+ minDay;
		} else {
			return ss[0] +"-"+ (Integer.valueOf(ss[1])+num) +"-"+ minDay;
		}
	}
	
	/**
	 * 获取指定日期所在月前后N个月的最后一天(负数表示前N个月，正数表示后N个月)
	 * @param date 日期 （yyyy-MM-dd）
	 * @return 日期 （yyyy-MM-dd）
	 */
	public static String getLastDayOfMonth(String date,Integer num) {
		String[] ss = date.split("-");
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.YEAR, Integer.valueOf(ss[0]));
		cal.set(Calendar.MONTH, Integer.valueOf(ss[1]) - (1-num));
		int maxDay = cal.getActualMaximum(Calendar.DATE);
		
		return ss[0] +"-"+ (Integer.valueOf(ss[1])+num) +"-"+ maxDay;
	}

	/**
	 * 获取指定日期所在季的第一天
	 * 
	 * @param date 日期 （yyyy-MM-dd）
	 * @return 日期 （yyyy-MM-dd）
	 */
	public static String getFirstDayOfQuarter(String date) {
		String[] ss = date.split("-");
		
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.YEAR, Integer.valueOf(ss[0]));
		cal.set(Calendar.MONTH, getQuarterInMonth(Integer.parseInt(ss[1])-1, true));
		cal.set(Calendar.DAY_OF_MONTH, 1);
		
		return format(cal.getTime());
	}

	/**
	 * 获取指定日期所在季的最后一天
	 * 
	 * @param date 日期 （yyyy-MM-dd）
	 * @return 日期 （yyyy-MM-dd）
	 */
	public static String getLastDayOfQuarter(String date) {
		String[] ss = date.split("-");
		
		Calendar cal = Calendar.getInstance();
		cal.set(Calendar.YEAR, Integer.valueOf(ss[0]));
		cal.set(Calendar.MONTH, getQuarterInMonth(Integer.parseInt(ss[1])-1, false) + 1);
		cal.set(Calendar.DAY_OF_MONTH, 0);
		
		return format(cal.getTime());
	}

	/**
	 * 返回当前季首/季末所在月，跟1月比相差的月数。
	 * 	季度一年四季， 第一季度：1月-3月， 第二季度：4月-6月， 第三季度：7月-9月， 第四季度：10月-12月
	 * @param month
	 * @param isQuarterStart
	 * @return
	 */
	private static int getQuarterInMonth(int month, boolean isQuarterStart) {
		int months[] = { 0, 3, 6, 9 };
		if (!isQuarterStart) {
			months = new int[] { 2, 5, 8, 11 };
		}
		if (month >= 0 && month <= 2)
			return months[0];
		else if (month >= 3 && month <= 5)
			return months[1];
		else if (month >= 6 && month <= 8)
			return months[2];
		else
			return months[3];
	}
	
	/**
	 * 获取当前日期
	 * @return Date
	 */
	public static Date getCurrDay(){
		Calendar calendar = Calendar.getInstance();
		return calendar.getTime();
	}
	
	/**
	 * 获取当前日期
	 * @return String
	 */
	public static String getCurrentDay(){
		Calendar calendar = Calendar.getInstance();
		Date date = calendar.getTime();
		return format(date);
	}
	/**
	 * 获取当前日指定格式日期
	 * @return String
	 */
	public static String getCurrentDay(String pattern){
		Calendar calendar = Calendar.getInstance();
		Date date = calendar.getTime();
		return format(date, pattern);
	}
	
	/**
	 * 获取当年的第一天
	 * 
	 * @param year
	 * @return Date
	 */
	public static Date getCurrYearFirst() {
		Calendar currCal = Calendar.getInstance();
		int currentYear = currCal.get(Calendar.YEAR);
		return getYearFirst(currentYear);
	}

	/**
	 * 获取当年的最后一天
	 * 
	 * @param year
	 * @return Date
	 */
	public static Date getCurrYearLast() {
		Calendar currCal = Calendar.getInstance();
		int currentYear = currCal.get(Calendar.YEAR);
		return getYearLast(currentYear);
	}

	/**
	 * 获取某年第一天
	 * 
	 * @param year 年份
	 * @return Date
	 */
	public static Date getYearFirst(int year) {
		Calendar calendar = Calendar.getInstance();
		calendar.clear();
		calendar.set(Calendar.YEAR, year);
		Date currYearFirst = calendar.getTime();
		
		return currYearFirst;
	}

	/**
	 * 获取某年最后一天
	 * 
	 * @param year 年份
	 * @return Date
	 */
	public static Date getYearLast(int year) {
		Calendar calendar = Calendar.getInstance();
		calendar.clear();
		calendar.set(Calendar.YEAR, year);
		calendar.roll(Calendar.DAY_OF_YEAR, -1);
		Date currYearLast = calendar.getTime();
		
		return currYearLast;
	}

	/**
	 * 判断指定日期是否为所在年的第一天
	 * 
	 * @param date
	 * @return boolean
	 */
	public static boolean judgeIsFirstDayOfYear(String date) {
		Date firstDay = getYearFirst(Integer.parseInt(format(parse(date), "yyyy")));
		if (format(parse(date)).equals(format(firstDay))) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 判断指定日期是否为所在年的最后一天
	 * 
	 * @param date
	 * @return boolean
	 */
	public static boolean judgeIsLastDayOfYear(String date) {
		Date lastDay = getYearLast(Integer.parseInt(format(parse(date), "yyyy")));
		if (format(parse(date)).equals(format(lastDay))) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 判断指定是否为所在月的第一天
	 * 
	 * @param date
	 * @return
	 */
	public static boolean judgeIsFirstDayOfMonth(String date) {
		String firstDay = getFirstDayOfMonth(date);
		if (date.equals(firstDay)) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 判断指定是否为所在月的最后一天
	 * 
	 * @param date
	 * @return
	 */
	public static boolean judgeIsLastDayOfMonth(String date) {
		String lastDay = getLastDayOfMonth(date);
		if (date.equals(lastDay)) {
			return true;
		} else {
			return false;
		}
	}
	
	/**
	 * 获取当天的起始时间
	 * @return
	 */
	public static Date getStartTime() {  
        Calendar todayStart = Calendar.getInstance();  
        todayStart.set(Calendar.HOUR_OF_DAY, 0);  
        todayStart.set(Calendar.MINUTE, 0);  
        todayStart.set(Calendar.SECOND, 0);  
        todayStart.set(Calendar.MILLISECOND, 001);  
        return todayStart.getTime();
    }  
	/**
	 * 获取当天的结束时间
	 * @return
	 */
	public static Date getEndTime() {  
    	Calendar todayEnd = Calendar.getInstance();  
        todayEnd.set(Calendar.HOUR_OF_DAY, 23);  
        todayEnd.set(Calendar.MINUTE, 59);  
        todayEnd.set(Calendar.SECOND, 59);  
        todayEnd.set(Calendar.MILLISECOND, 999);  
        return todayEnd.getTime(); 
    } 
	
	/**
	 * 获取昨天的时间
	 * @return
	 */
	public static Date getYesterday() {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(DateUtils.getCurrDay());
		calendar.add(Calendar.DAY_OF_MONTH, -1);
		return calendar.getTime();
	}  
	/**
	 * 获取昨天的起始时间
	 * @return
	 */
	public static Date getYStartTime() {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(DateUtils.getYesterday());
		calendar.set(Calendar.HOUR_OF_DAY, 0);  
		calendar.set(Calendar.MINUTE, 0);  
		calendar.set(Calendar.SECOND, 0);  
//		calendar.set(Calendar.MILLISECOND, 001);  
        return calendar.getTime();
	}  
	
	/**
	 * 获取昨天的结束时间
	 * @return
	 */
	public static Date getYEndTime() {  
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(DateUtils.getYesterday());
		calendar.set(Calendar.HOUR_OF_DAY, 23);  
		calendar.set(Calendar.MINUTE, 59);  
		calendar.set(Calendar.SECOND, 59);  
//		calendar.set(Calendar.MILLISECOND, 999);  
		return calendar.getTime(); 
	}
	
	/**
	 * 获取当前日期的所在周的下一周的第一天（财富预算统计日期周六）
	 * @return
	 */
	public static Date getMonDayTime() {
		Calendar todayEnd = Calendar.getInstance();
		todayEnd.set(Calendar.DAY_OF_WEEK, Calendar.SATURDAY);
		return todayEnd.getTime();
	}
	
	/**
	 * 获取当前日期的所在周的下一周的第七天（财富预算统计日期周五）
	 * @return
	 */
	public static Date getSunDayTime() {
		Calendar todayEnd = Calendar.getInstance();
		todayEnd.set(Calendar.DAY_OF_WEEK, Calendar.FRIDAY);
		todayEnd.add(Calendar.DAY_OF_MONTH, 7);
		return todayEnd.getTime();
	}
	
	/**
	 * 取得一年的第几周 
	 * @param date
	 * @return
	 */
    public static int getWeekOfYear(Date date) {  
        Calendar c = Calendar.getInstance();  
        c.setTime(date);  
        int week_of_year = c.get(Calendar.WEEK_OF_YEAR);  
        return week_of_year;  
    }
    
    /** 
     * 取得日期：年 
     *  
     * @param date 
     * @return 
     */  
    public static int getYear(Date date) {  
        Calendar c = Calendar.getInstance();  
        c.setTime(date);  
        int year = c.get(Calendar.YEAR);  
        return year;  
    }  
  
    /** 
     * 取得日期：月 
     *  
     * @param date 
     * @return 
     */  
    public static int getMonth(Date date) {  
        Calendar c = Calendar.getInstance();  
        c.setTime(date);  
        int month = c.get(Calendar.MONTH);  
        return month + 1;  
    }
    
    /** 
     *  
     * 1 第一季度 2 第二季度 3 第三季度 4 第四季度 
     *  
     * @param date 
     * @return 
     */  
    public static int getSeason(Date date) {  
  
        int season = 0;  
  
        Calendar c = Calendar.getInstance();  
        c.setTime(date);  
        int month = c.get(Calendar.MONTH);  
        switch (month) {  
        case Calendar.JANUARY:  
        case Calendar.FEBRUARY:  
        case Calendar.MARCH:  
            season = 1;  
            break;  
        case Calendar.APRIL:  
        case Calendar.MAY:  
        case Calendar.JUNE:  
            season = 2;  
            break;  
        case Calendar.JULY:  
        case Calendar.AUGUST:  
        case Calendar.SEPTEMBER:  
            season = 3;  
            break;  
        case Calendar.OCTOBER:  
        case Calendar.NOVEMBER:  
        case Calendar.DECEMBER:  
            season = 4;  
            break;  
        default:  
            break;  
        }  
        return season;  
    }
    /**
	 * 获取前天的时间
	 * @return
	 */
	public static Date getBeforeYesterday() {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(DateUtils.getCurrDay());
		calendar.add(Calendar.DAY_OF_MONTH, -2);
		return calendar.getTime();
	}  
	/**
	 * 获取前天的起始时间
	 * @return
	 */
	public static Date getBYStartTime() {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(DateUtils.getBeforeYesterday());
		calendar.set(Calendar.HOUR_OF_DAY, 0);  
		calendar.set(Calendar.MINUTE, 0);  
		calendar.set(Calendar.SECOND, 0);  
//		calendar.set(Calendar.MILLISECOND, 001);  
		return calendar.getTime();
	} 

	/**
	 * 下个月10号
	 * @return
	 */
	public static Date getnextMonthday() {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(DateUtils.getCurrDay());
		calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) + 1);
		calendar.set(Calendar.DATE, 10);
		return calendar.getTime();
	}
	/**
	 * 下下个月10号
	 * @return
	 */
	public static Date getDoubelnextMonthday() {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(DateUtils.getCurrDay());
		calendar.set(Calendar.MONTH, calendar.get(Calendar.MONTH) + 2);
		calendar.set(Calendar.DATE, 10);
		return calendar.getTime();
	} 
	
	/**
	 * 获取两年后的起始时间
	 * @return
	 */
	public static Date getTwoYearsStartTime() {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(DateUtils.getStartTime());
		calendar.add(Calendar.YEAR, 2);
		return calendar.getTime();
	} 
	

	public static void main(String[] args) throws ParseException {
//		System.out.println(getFirstDayOfQuarter("2017-09-18"));
//		System.out.println(getBeforeYesterday());
//		System.out.println(getBYStartTime());
//		System.out.println(getBYStartTime().getTime());
		/*Calendar calendar = Calendar.getInstance();
		calendar.setTime(DateUtils.getCurrDay());
		calendar.add(Calendar.DAY_OF_MONTH, -1);
		Date yesterday = calendar.getTime();//昨天日期
		calendar.set(Calendar.HOUR_OF_DAY, 23);  
		calendar.set(Calendar.MINUTE, 59);  
		calendar.set(Calendar.SECOND, 59);  
		calendar.set(Calendar.MILLISECOND, 999);   
		System.out.println(calendar.getTime());*/
		
		System.out.println(getLastDayOfMonth("2018-02-01"));
		System.out.println(format(DateUtils.getDoubelnextMonthday()));
	}
}
